home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #4 / Amiga Plus CD - 2000 - No. 4.iso / Vollversion / CamD / development / examples / capture / capture_tm.c < prev    next >
C/C++ Source or Header  |  2000-05-15  |  21KB  |  832 lines
  1.  
  2. /* Code generated by Toolmaker V1.13 */
  3.  
  4. /* Includes */
  5.  
  6. #include <stdlib.h>
  7. #include <exec/types.h>
  8. #include <intuition/intuition.h>
  9. #include <intuition/gadgetclass.h>
  10. #include <libraries/gadtools.h>
  11. #include <exec/memory.h>
  12. #include <graphics/view.h>
  13. #include <graphics/displayinfo.h>
  14.  
  15. #include "capture.h"
  16.  
  17. #include <clib/exec_protos.h>
  18. #include <clib/intuition_protos.h>
  19. #include <clib/gadtools_protos.h>
  20.  
  21. /* Pragma includes for register parameters */
  22.  
  23. #include <pragmas/exec_pragmas.h>
  24. #include <pragmas/intuition_pragmas.h>
  25. #include <pragmas/gadtools_pragmas.h>
  26.  
  27. /* static function prototypes */
  28.  
  29. static BOOL TM_WindowSignal(struct TMData *);
  30. static VOID TM_RemoveWindow(struct TMWindowInfo *);
  31. static BOOL WindowIDCMP_CAPTUREM(struct TMData *, struct IntuiMessage *);
  32.  
  33. /* Mouse pointer data for disabled window */
  34.  
  35. #ifdef _DCC    /* For DICE compatibiliity */
  36. __chip UWORD WaitPointer[36] =
  37. #else
  38. UWORD __chip WaitPointer[36] =
  39. #endif
  40.   {
  41.   0x0000, 0x0000,
  42.   0x0400, 0x07C0,
  43.   0x0000, 0x07C0,
  44.   0x0100, 0x0380,
  45.   0x0000, 0x07E0,
  46.   0x07C0, 0x1FF8,
  47.   0x1FF0, 0x3FEC,
  48.   0x3FF8, 0x7FDE,
  49.   0x3FF8, 0x7FBE,
  50.   0x7FFC, 0xFF7F,
  51.   0x7EFC, 0xFFFF,
  52.   0x7FFC, 0xFFFF,
  53.   0x3FF8, 0x7FFE,
  54.   0x3FF8, 0x7FFE,
  55.   0x1FF0, 0x3FFC,
  56.   0x07C0, 0x1FF8,
  57.   0x0000, 0x07E0,
  58.   0x0000, 0x0000,
  59.   };
  60.  
  61. /* Screen data */
  62.  
  63. /* Window data */
  64.  
  65. struct NewMenu newmenu_CAPTUREM[] =
  66.   {
  67.   {NM_TITLE, (UBYTE *)MENUTEXT_PROJECT,    NULL,    0,    0,    NULL},    /* Project */
  68.   {NM_ITEM,  (UBYTE *)ITEMTEXT_CLEAR,    NULL,    0,    0,    (APTR) &tmobjectdata_CLEAR},    /* Clear */
  69.   {NM_ITEM,  (UBYTE *)ITEMTEXT_LOAD,    (UBYTE *)"L",    0,    0,    (APTR) &tmobjectdata_LOAD},    /* Load... */
  70.   {NM_ITEM,  (UBYTE *)ITEMTEXT_SAVE,    (UBYTE *)"S",    0,    0,    (APTR) &tmobjectdata_SAVE},    /* Save... */
  71.   {NM_ITEM,  NM_BARLABEL,    NULL,    0,    0,    NULL},    /* --- */
  72.   {NM_ITEM,  (UBYTE *)ITEMTEXT_ABOUT,    NULL,    0,    0,    (APTR) &tmobjectdata_ABOUT},    /* About... */
  73.   {NM_ITEM,  NM_BARLABEL,    NULL,    0,    0,    NULL},    /* --- */
  74.   {NM_ITEM,  (UBYTE *)ITEMTEXT_QUIT,    (UBYTE *)"Q",    0,    0,    (APTR) &tmobjectdata_QUIT},    /* Quit */
  75.   {NM_TITLE, (UBYTE *)MENUTEXT_SETTINGS,    NULL,    0,    0,    NULL},    /* Settings */
  76.   {NM_ITEM,  (UBYTE *)ITEMTEXT_SETOUTPU,    (UBYTE *)"1",    0,    0,    (APTR) &tmobjectdata_SETOUTPU},    /* Set Output Link... */
  77.   {NM_ITEM,  (UBYTE *)ITEMTEXT_SETINPUT,    (UBYTE *)"2",    0,    0,    (APTR) &tmobjectdata_SETINPUT},    /* Set Input Link... */
  78.   {NM_END,   NULL,    NULL,    0,    0,    NULL}
  79.   };
  80.  
  81.  
  82. /* Font data */
  83.  
  84. struct TextAttr topaz8 =
  85.   {
  86.   (STRPTR)"topaz.font",    /* ta_Name */
  87.   8,    /* ta_YSize */
  88.   FS_NORMAL,    /* ta_Style */
  89.   0x0    /* ta_Flags */
  90.   };
  91.  
  92. /****** capture_tm.c/TM_Request *****************************
  93. *
  94. *   NAME
  95. *    TM_Request -- display a message in a system requester.
  96. *
  97. *   SYNOPSIS
  98. *    num = TM_Request(Window, Title, TextFormat, GadgetFormat,
  99. *                     IDCMP_ptr, Arg1, Arg2, ...)
  100. *
  101. *    LONG TM_Request(struct Window *, UBYTE *, UBYTE *, UBYTE *,
  102. *                    ULONG *, APTR, ...);
  103. *
  104. *   FUNCTION
  105. *    Calls EasyRequestArgs to display a message in a system
  106. *    requester without having to fill in an EasyStruct structure.
  107. *    This function uses a varargs calling convention.
  108. *
  109. *    EasyRequestArgs has the capability to display more than one
  110. *    gadget by separating the GadgetText with the '|' character.
  111. *    Also printf style formatting may be used in the TextFormat
  112. *    and GadgetFormat strings.  The formatting arguments should
  113. *    be added first for the TextFormat, then for the GadgetFormat.
  114. *
  115. *   INPUTS
  116. *    Window = pointer to window (passed to EasyRequestArgs()).
  117. *    Title = title bar string (passed to EasyRequestArgs()).
  118. *    TextFormat = body text (passed to EasyRequestArgs()).
  119. *    GadgetFormat = gadget text (passed to EasyRequestArgs()).
  120. *    IDCMP_ptr = IDCMP value (passed to EasyRequestArgs()).
  121. *    Args = arguments (passed to EasyRequestArgs()).
  122. *
  123. *   RESULT
  124. *    num = gadget number returned by EasyRequestArgs().
  125. *
  126. *   EXAMPLE
  127. *    To display a requester with two choices:
  128. *
  129. *    result = TM_Request(NULL, "Question", "Are you sure?",
  130. *                        "OK|Cancel", NULL, NULL);
  131. *
  132. *   NOTES
  133. *    The intuition library must be open before calling this
  134. *    function.
  135. *
  136. *   BUGS
  137. *
  138. *   SEE ALSO
  139. *    intuition.library/EasyRequestArgs()
  140. *
  141. **************************************************************
  142. *
  143. */
  144. LONG TM_Request(struct Window *Window, UBYTE *Title, UBYTE *TextFormat, UBYTE *GadgetFormat, ULONG *IDCMP_ptr, APTR Arg1, ...)
  145.   {
  146.   struct EasyStruct es;
  147.  
  148.   es.es_StructSize = sizeof(struct EasyStruct);
  149.   es.es_Flags = 0;
  150.   es.es_Title = Title;
  151.   es.es_TextFormat = TextFormat;
  152.   es.es_GadgetFormat = GadgetFormat;
  153.  
  154.   return(EasyRequestArgs(Window, &es, IDCMP_ptr, &Arg1));
  155.   }
  156.  
  157. /****** capture_tm.c/TM_Open *****************************
  158. *
  159. *   NAME
  160. *    TM_Open -- initialize user-interface data.
  161. *
  162. *   SYNOPSIS
  163. *    TMData = TM_Open(ErrorCode)
  164. *
  165. *    struct TMData *TM_Open(ULONG *error);
  166. *
  167. *   FUNCTION
  168. *    Creates an initializes a TMData structure.  This
  169. *    includes allocating memory for a TMData structure,
  170. *    creating a message port for window IDCMP messages,
  171. *    and opening any fonts on disk.
  172. *
  173. *   INPUTS
  174. *    error = pointer to ULONG to store an error number.
  175. *            Error numbers are defined in the _tm.h file.
  176. *
  177. *   RESULT
  178. *    TMData = pointer to an initialized TMData structure
  179. *             or NULL if an error occurred.
  180. *
  181. *   EXAMPLE
  182. *    if(!(TMData = TM_Open(&error)))
  183. *      {
  184. *      switch(error)
  185. *        {
  186. *        case TMERR_MEMORY:
  187. *          TM_Request(NULL, "Error", "Out of memory", "Abort", NULL, NULL);
  188. *          break;
  189. *        case TMERR_MSGPORT:
  190. *          TM_Request(NULL, "Error", "Error creating\nmessage port", "Abort", NULL, NULL);
  191. *          break;
  192. *        }
  193. *      CleanExit(NULL, RETURN_FAIL);
  194. *      }
  195. *
  196. *   NOTES
  197. *    The intuition and gadtools libraries must be open before
  198. *    calling this function.  If any fonts other than topaz 8
  199. *    and topaz 9 are used, the diskfont and graphics libraries
  200. *    must also be open.
  201. *
  202. *   BUGS
  203. *
  204. *   SEE ALSO
  205. *    TM_Close()
  206. *
  207. **************************************************************
  208. *
  209. */
  210. struct TMData *TM_Open(ULONG *error)
  211.   {
  212.   struct TMData *tmdata;
  213.  
  214.   if(tmdata = AllocMem(sizeof(struct TMData), MEMF_CLEAR))
  215.     {
  216.     tmdata->Size = sizeof(struct TMData);
  217.  
  218.     if(tmdata->WindowMsgPort = CreateMsgPort())
  219.       {
  220.       *error = TMERR_OK;
  221.       return(tmdata);
  222.       }
  223.     else
  224.       {
  225.       *error = TMERR_MSGPORT;
  226.       }
  227.     FreeMem(tmdata, sizeof(struct TMData));
  228.     }
  229.   else
  230.     {
  231.     *error = TMERR_MEMORY;
  232.     }
  233.  
  234.   return(NULL);
  235.   }
  236.  
  237. /****** capture_tm.c/TM_Close *****************************
  238. *
  239. *   NAME
  240. *    TM_Close -- frees user-interface data.
  241. *
  242. *   SYNOPSIS
  243. *    TM_Close(TMData)
  244. *
  245. *    VOID TM_Close(struct TMData *TMData);
  246. *
  247. *   FUNCTION
  248. *    Frees resources allocated by TM_Open().
  249. *
  250. *   INPUTS
  251. *    TMData = pointer to TMData structure returned by TM_Open.
  252. *
  253. *   RESULT
  254. *
  255. *   EXAMPLE
  256. *    if(TMData) TM_Close(TMData);
  257. *
  258. *   NOTES
  259. *
  260. *   BUGS
  261. *
  262. *   SEE ALSO
  263. *    TM_Open()
  264. *
  265. **************************************************************
  266. *
  267. */
  268. VOID TM_Close(struct TMData *TMData)
  269.   {
  270.   if(TMData)
  271.     {
  272.     if(TMData->WindowMsgPort) DeleteMsgPort(TMData->WindowMsgPort);
  273.     FreeMem(TMData, TMData->Size);
  274.     }
  275.   }
  276.  
  277. /****** capture_tm.c/TM_EventLoop *****************************
  278. *
  279. *   NAME
  280. *    TM_EventLoop -- waits for all events.
  281. *
  282. *   SYNOPSIS
  283. *    TM_EventLoop(TMData)
  284. *
  285. *    VOID TM_EventLoop(struct TMData *);
  286. *
  287. *   FUNCTION
  288. *    Waits for any events to signal program.  All IDCMP, ARexx,
  289. *    and a user signal messages received are sent to the
  290. *    appropriate signal function.  A return value of TRUE from
  291. *    any of the signal functions will terminate the loop.
  292. *
  293. *   INPUTS
  294. *    TMData = pointer to TMData structure returned by TM_Open.
  295. *
  296. *   RESULT
  297. *
  298. *   EXAMPLE
  299. *    TM_EventLoop(TMData);
  300. *
  301. *   NOTES
  302. *    An event signal must be set up before calling TM_EventLoop.
  303. *    Either a window must be open, the SimpleRexx option selected,
  304. *    or a user signal set up.
  305. *
  306. *   BUGS
  307. *
  308. *   SEE ALSO
  309. *    TM_WindowSignal(), TM_ARexxSignal(), exec.library/Wait()
  310. *
  311. **************************************************************
  312. *
  313. */
  314. VOID TM_EventLoop(struct TMData *TMData)
  315.   {
  316.   BOOL done=FALSE, result;
  317.   ULONG windowsignal, signals;
  318.  
  319.   windowsignal = 1L << TMData->WindowMsgPort->mp_SigBit;
  320.  
  321.   while(!done)
  322.     {
  323.     signals = Wait(windowsignal | SIGBREAKF_CTRL_E);
  324.  
  325.     if (signals & windowsignal)
  326.       {
  327.       if(result = TM_WindowSignal(TMData)) done = result;
  328.       }
  329.  
  330.         if (signals & SIGBREAKF_CTRL_E)
  331.         {    HandleMidi( TMData );
  332.         }
  333.     }
  334. }
  335.  
  336. /****** capture_tm.c/OpenScreen_Workbench *****************************
  337. *
  338. *   NAME
  339. *    OpenScreen_Workbench -- Use the default public screen.
  340. *
  341. *   SYNOPSIS
  342. *    success = OpenScreen_Workbench(TMData)
  343. *
  344. *    BOOL OpenScreen_Workbench(struct TMData *);
  345. *
  346. *   FUNCTION
  347. *    Locks the default public screen and gets its visual info.  If the
  348. *    screen was already locked, it will be brought to front.
  349. *
  350. *   INPUTS
  351. *    TMData = pointer to the TMData structure returned by TM_Open.
  352. *
  353. *   RESULT
  354. *    success = TRUE if command was successfully completed.
  355. *              FALSE if not.
  356. *
  357. *   EXAMPLE
  358. *    if(!(OpenScreen_Workbench(TMData)))
  359. *      {
  360. *      TM_Request(NULL, "Error", "Error opening screen", "Abort", NULL, NULL);
  361. *      CleanExit(TMData, RETURN_FAIL);
  362. *      }
  363. *
  364. *   NOTES
  365. *
  366. *   BUGS
  367. *
  368. *   SEE ALSO
  369. *    CloseScreen_Workbench()
  370. *
  371. **************************************************************
  372. *
  373. */
  374. BOOL OpenScreen_Workbench(struct TMData *TMData)
  375.   {
  376.   if(ScreenInfo_Workbench.Screen)
  377.     {
  378.     ScreenToFront(ScreenInfo_Workbench.Screen);
  379.     return(TRUE);
  380.     }
  381.   else
  382.     {
  383.     if(ScreenInfo_Workbench.Screen = LockPubScreen(NULL))
  384.       {
  385.       if(ScreenInfo_Workbench.VisualInfo = GetVisualInfo(ScreenInfo_Workbench.Screen, TAG_DONE))
  386.         {
  387.         return(TRUE);
  388.         }
  389.       UnlockPubScreen(NULL, ScreenInfo_Workbench.Screen);
  390.       }
  391.     }
  392.  
  393.   return(FALSE);
  394.   }
  395.  
  396. /****** capture_tm.c/CloseScreen_Workbench *****************************
  397. *
  398. *   NAME
  399. *    CloseScreen_Workbench -- Free the default public screen.
  400. *
  401. *   SYNOPSIS
  402. *    CloseScreen_Workbench(TMData)
  403. *
  404. *    VOID CloseScreen_Workbench(struct TMData *);
  405. *
  406. *   FUNCTION
  407. *    Unlocks the default public screen and frees the visual info.
  408. *    It's ok to re-close a screen that is already closed.
  409. *
  410. *   INPUTS
  411. *    TMData = pointer to the TMData structure returned by TM_Open.
  412. *
  413. *   RESULT
  414. *
  415. *   EXAMPLE
  416. *    CloseScreen_Workbench(TMData);
  417. *
  418. *   NOTES
  419. *
  420. *   BUGS
  421. *
  422. *   SEE ALSO
  423. *    OpenScreen_Workbench()
  424. *
  425. **************************************************************
  426. *
  427. */
  428. VOID CloseScreen_Workbench(struct TMData *TMData)
  429.   {
  430.   if(ScreenInfo_Workbench.VisualInfo)
  431.     {
  432.     FreeVisualInfo(ScreenInfo_Workbench.VisualInfo);
  433.     ScreenInfo_Workbench.VisualInfo = NULL;
  434.     }
  435.   if(ScreenInfo_Workbench.Screen)
  436.     {
  437.     UnlockPubScreen(NULL, ScreenInfo_Workbench.Screen);
  438.     ScreenInfo_Workbench.Screen = NULL;
  439.     }
  440.   }
  441.  
  442. /****** capture_tm.c/OpenWindow_CAPTUREM *****************************
  443. *
  444. *   NAME
  445. *    OpenWindow_CAPTUREM -- Open window "CAPTUREM".
  446. *
  447. *   SYNOPSIS
  448. *    success = OpenWindow_CAPTUREM(TMData)
  449. *
  450. *    BOOL OpenWindow_CAPTUREM(struct TMData *);
  451. *
  452. *   FUNCTION
  453. *    Opens the window with label "CAPTUREM"
  454. *    along with any gadgets it contains.  If the window was already
  455. *    open, it will be brought to front.
  456. *
  457. *   INPUTS
  458. *    TMData = pointer to the TMData structure returned by TM_Open.
  459. *
  460. *   RESULT
  461. *    success = TRUE if command was successfully completed.
  462. *              FALSE if not.
  463. *
  464. *   EXAMPLE
  465. *    if(!OpenWindow_CAPTUREM(TMData))
  466. *      {
  467. *      TMRequest(NULL, "Error", "Error opening window", "Abort", NULL, NULL);
  468. *      CleanExit(TMData, RETURN_FAIL);
  469. *      }
  470. *   NOTES
  471. *
  472. *   BUGS
  473. *
  474. *   SEE ALSO
  475. *    CloseWindow_CAPTUREM()
  476. *
  477. **************************************************************
  478. *
  479. */
  480. BOOL OpenWindow_CAPTUREM(struct TMData *TMData)
  481.   {
  482.   ULONG lasttag;
  483.   struct NewGadget ng;
  484.  
  485.   if(WindowInfo_CAPTUREM.Window)
  486.     {
  487.     WindowToFront(WindowInfo_CAPTUREM.Window);
  488.     ActivateWindow(WindowInfo_CAPTUREM.Window);
  489.     return(TRUE);
  490.     }
  491.   else
  492.     {
  493.     WindowInfo_CAPTUREM.FirstGadget = NULL;
  494.     WindowInfo_CAPTUREM.ContextGadget = CreateContext(&WindowInfo_CAPTUREM.FirstGadget);
  495.  
  496.     ng.ng_VisualInfo = ScreenInfo_Workbench.VisualInfo;
  497.  
  498.     ng.ng_LeftEdge = 248;
  499.     ng.ng_TopEdge = 19+ScreenInfo_Workbench.Screen->BarHeight;
  500.     ng.ng_Width = 76;
  501.     ng.ng_Height = 16;
  502.     ng.ng_Flags = PLACETEXT_IN;
  503.     ng.ng_TextAttr = &topaz8;
  504.     ng.ng_GadgetText = (UBYTE *)GADGETTEXT_CLEAR;    /* Clear */
  505.     ng.ng_GadgetID = ID_CLEAR;
  506.     ng.ng_UserData = (APTR) &tmobjectdata_CLEAR;
  507.     lasttag = GadgetInfo_CLEAR.MoreTags ? TAG_MORE : TAG_DONE;
  508.     GadgetInfo_CLEAR.Gadget = CreateGadget(BUTTON_KIND, WindowInfo_CAPTUREM.ContextGadget, &ng,
  509.         lasttag, GadgetInfo_CLEAR.MoreTags);
  510.  
  511.     ng.ng_LeftEdge = 168;
  512.     ng.ng_GadgetText = (UBYTE *)GADGETTEXT_SEND;    /* Send */
  513.     ng.ng_GadgetID = ID_SEND;
  514.     ng.ng_UserData = (APTR) &tmobjectdata_SEND;
  515.     lasttag = GadgetInfo_SEND.MoreTags ? TAG_MORE : TAG_DONE;
  516.     GadgetInfo_SEND.Gadget = CreateGadget(BUTTON_KIND, GadgetInfo_CLEAR.Gadget, &ng,
  517.         lasttag, GadgetInfo_SEND.MoreTags);
  518.  
  519.     ng.ng_LeftEdge = 88;
  520.     ng.ng_GadgetText = (UBYTE *)GADGETTEXT_SAVE;    /* Save... */
  521.     ng.ng_GadgetID = ID_SAVE;
  522.     ng.ng_UserData = (APTR) &tmobjectdata_SAVE;
  523.     lasttag = GadgetInfo_SAVE.MoreTags ? TAG_MORE : TAG_DONE;
  524.     GadgetInfo_SAVE.Gadget = CreateGadget(BUTTON_KIND, GadgetInfo_SEND.Gadget, &ng,
  525.         lasttag, GadgetInfo_SAVE.MoreTags);
  526.  
  527.     ng.ng_LeftEdge = 8;
  528.     ng.ng_GadgetText = (UBYTE *)GADGETTEXT_LOAD;    /* Load... */
  529.     ng.ng_GadgetID = ID_LOAD;
  530.     ng.ng_UserData = (APTR) &tmobjectdata_LOAD;
  531.     lasttag = GadgetInfo_LOAD.MoreTags ? TAG_MORE : TAG_DONE;
  532.     GadgetInfo_LOAD.Gadget = CreateGadget(BUTTON_KIND, GadgetInfo_SAVE.Gadget, &ng,
  533.         lasttag, GadgetInfo_LOAD.MoreTags);
  534.  
  535.     ng.ng_LeftEdge = 208;
  536.     ng.ng_TopEdge = 3+ScreenInfo_Workbench.Screen->BarHeight;
  537.     ng.ng_Width = 116;
  538.     ng.ng_Height = 14;
  539.     ng.ng_Flags = PLACETEXT_LEFT;
  540.     ng.ng_GadgetText = (UBYTE *)GADGETTEXT_BYTESINB;    /* Bytes in Buffer */
  541.     ng.ng_GadgetID = 0;
  542.     ng.ng_UserData = NULL;
  543.     lasttag = GadgetInfo_BYTESINB.MoreTags ? TAG_MORE : TAG_DONE;
  544.     GadgetInfo_BYTESINB.Gadget = CreateGadget(NUMBER_KIND, GadgetInfo_LOAD.Gadget, &ng,
  545.         GTNM_Border, TRUE,
  546.         lasttag, GadgetInfo_BYTESINB.MoreTags);
  547.  
  548.     if(GadgetInfo_BYTESINB.Gadget)
  549.       {
  550.       lasttag = WindowInfo_CAPTUREM.MoreTags ? TAG_MORE : TAG_DONE;
  551.  
  552.       if((WindowInfo_CAPTUREM.Window = OpenWindowTags(NULL,
  553.         WA_PubScreen, ScreenInfo_Workbench.Screen,
  554.         WA_Title, WINDOWTEXT_CAPTUREM,    /* MIDI Capture */
  555.         WA_IDCMP, NULL,
  556.         WA_Gadgets, WindowInfo_CAPTUREM.FirstGadget,
  557.         WA_Left, 157,
  558.         WA_Top, 88,
  559.         WA_InnerWidth, 324,
  560.         WA_InnerHeight, 37,
  561.         WA_DragBar, TRUE,
  562.         WA_CloseGadget, TRUE,
  563.         WA_DepthGadget, TRUE,
  564.         WA_Activate, TRUE,
  565.         WA_SimpleRefresh, TRUE,
  566.         lasttag, WindowInfo_CAPTUREM.MoreTags)))
  567.         {
  568.         if((WindowInfo_CAPTUREM.Menu = CreateMenus(newmenu_CAPTUREM, TAG_DONE)))
  569.           {
  570.           if((LayoutMenus(WindowInfo_CAPTUREM.Menu, ScreenInfo_Workbench.VisualInfo, TAG_DONE)))
  571.             {
  572.             if((SetMenuStrip(WindowInfo_CAPTUREM.Window, WindowInfo_CAPTUREM.Menu)))
  573.               {
  574.               WindowInfo_CAPTUREM.Window->UserPort = TMData->WindowMsgPort;
  575.               ModifyIDCMP(WindowInfo_CAPTUREM.Window,
  576.             IDCMP_REFRESHWINDOW |
  577.             BUTTONIDCMP |
  578.             IDCMP_GADGETDOWN |
  579.             IDCMP_GADGETUP |
  580.             IDCMP_MENUPICK |
  581.             IDCMP_CLOSEWINDOW);
  582.               GT_RefreshWindow(WindowInfo_CAPTUREM.Window, NULL);
  583.               WindowInfo_CAPTUREM.Flags |= TMWF_OPENED;
  584.               return(TRUE);
  585.               }
  586.             }
  587.           FreeMenus(WindowInfo_CAPTUREM.Menu);
  588.           }
  589.         CloseWindow(WindowInfo_CAPTUREM.Window);
  590.         }
  591.       FreeGadgets(WindowInfo_CAPTUREM.FirstGadget);
  592.       }
  593.     }
  594.   return(FALSE);
  595.   }
  596.  
  597. /****** capture_tm.c/CloseWindow_CAPTUREM *****************************
  598. *
  599. *   NAME
  600. *    CloseWindow_CAPTUREM -- Close window "CAPTUREM".
  601. *
  602. *   SYNOPSIS
  603. *    CloseWindow_CAPTUREM(TMData)
  604. *
  605. *    VOID CloseWindow_CAPTUREM(struct TMData *);
  606. *
  607. *   FUNCTION
  608. *    Closes the window with label "CAPTUREM"
  609. *    and frees its resources.  It's ok to re-close a window
  610. *    that is already closed.
  611. *
  612. *   INPUTS
  613. *    TMData = pointer to the TMData structure returned by TM_Open.
  614. *
  615. *   RESULT
  616. *
  617. *   EXAMPLE
  618. *
  619. *   NOTES
  620. *
  621. *   BUGS
  622. *
  623. *   SEE ALSO
  624. *    OpenWindow_CAPTUREM()
  625. *
  626. **************************************************************
  627. *
  628. */
  629. VOID CloseWindow_CAPTUREM(struct TMData *TMData)
  630.   {
  631.   TM_RemoveWindow(&WindowInfo_CAPTUREM);
  632.   }
  633.  
  634. /****** capture_tm.c/DisableWindow_CAPTUREM *****************************
  635. *
  636. *   NAME
  637. *    DisableWindow_CAPTUREM -- disable input to window "CAPTUREM".
  638. *
  639. *   SYNOPSIS
  640. *    DisableWindow_CAPTUREM(TMData)
  641. *
  642. *    VOID DisableWindow_CAPTUREM(struct TMData *);
  643. *
  644. *   FUNCTION
  645. *    Disables all input to window with label "CAPTUREM"
  646. *    and changes its mouse pointer.
  647. *
  648. *   INPUTS
  649. *    TMData = pointer to the TMData structure returned by TM_Open.
  650. *
  651. *   RESULT
  652. *
  653. *   EXAMPLE
  654. *
  655. *   NOTES
  656. *
  657. *   BUGS
  658. *
  659. *   SEE ALSO
  660. *    EnableWindow_CAPTUREM()
  661. *
  662. **************************************************************
  663. *
  664. */
  665. VOID DisableWindow_CAPTUREM(struct TMData *TMData)
  666.   {
  667.   if((WindowInfo_CAPTUREM.DisableCount == 0) && (WindowInfo_CAPTUREM.Flags & TMWF_OPENED))
  668.     {
  669.     InitRequester(&WindowInfo_CAPTUREM.Requester);
  670.     if(Request(&WindowInfo_CAPTUREM.Requester, WindowInfo_CAPTUREM.Window))
  671.       {
  672.       WindowInfo_CAPTUREM.Flags |= TMWF_DISABLED;
  673.       SetPointer(WindowInfo_CAPTUREM.Window, WaitPointer, 16, 16, -6, 0);
  674.       }
  675.     }
  676.   WindowInfo_CAPTUREM.DisableCount++;
  677.   }
  678.  
  679. /****** capture_tm.c/EnableWindow_CAPTUREM *****************************
  680. *
  681. *   NAME
  682. *    EnableWindow_CAPTUREM -- enable input to window "CAPTUREM".
  683. *
  684. *   SYNOPSIS
  685. *    EnableWindow_CAPTUREM(TMData)
  686. *
  687. *    VOID EnableWindow_CAPTUREM(struct TMData *);
  688. *
  689. *   FUNCTION
  690. *    Enables input to window with label "CAPTUREM"
  691. *    and clears its mouse pointer.
  692. *
  693. *   INPUTS
  694. *    TMData = pointer to the TMData structure returned by TM_Open.
  695. *
  696. *   RESULT
  697. *
  698. *   EXAMPLE
  699. *
  700. *   NOTES
  701. *
  702. *   BUGS
  703. *
  704. *   SEE ALSO
  705. *    DisableWindow_CAPTUREM()
  706. *
  707. **************************************************************
  708. *
  709. */
  710. VOID EnableWindow_CAPTUREM(struct TMData *TMData)
  711.   {
  712.   WindowInfo_CAPTUREM.DisableCount--;
  713.   if((WindowInfo_CAPTUREM.DisableCount == 0) && (WindowInfo_CAPTUREM.Flags & (TMWF_DISABLED | TMWF_OPENED)))
  714.     {
  715.     EndRequest(&WindowInfo_CAPTUREM.Requester, WindowInfo_CAPTUREM.Window);
  716.     WindowInfo_CAPTUREM.Flags &= ~TMWF_DISABLED;
  717.     ClearPointer(WindowInfo_CAPTUREM.Window);
  718.     }
  719.   }
  720.  
  721. /* *********************************************************** */
  722. /* Static functions (available only to functions in this file) */
  723. /* *********************************************************** */
  724.  
  725. static BOOL TM_WindowSignal(struct TMData *TMData)
  726.   {
  727.   BOOL done=FALSE;
  728.   BOOL result;
  729.   struct IntuiMessage *imessage;
  730.  
  731.   while(imessage = GT_GetIMsg(TMData->WindowMsgPort))
  732.     {
  733.     if(imessage->IDCMPWindow == WindowInfo_CAPTUREM.Window)
  734.       {
  735.       WindowInfo_CAPTUREM.GT_IMsg = imessage;
  736.       if(result = WindowIDCMP_CAPTUREM(TMData, imessage)) done = result;
  737.       if(WindowInfo_CAPTUREM.GT_IMsg)
  738.         {
  739.         GT_ReplyIMsg(WindowInfo_CAPTUREM.GT_IMsg);
  740.         WindowInfo_CAPTUREM.GT_IMsg = NULL;
  741.         }
  742.       }
  743.     }
  744.  
  745.   return(done);
  746.   }
  747.  
  748. static BOOL WindowIDCMP_CAPTUREM(struct TMData *TMData, struct IntuiMessage *imessage)
  749.   {
  750.   BOOL done=FALSE;
  751.   BOOL result;
  752.  
  753.   switch(imessage->Class)
  754.     {
  755.     case IDCMP_REFRESHWINDOW:    /* Always refresh */
  756.       GT_BeginRefresh(WindowInfo_CAPTUREM.Window);
  757.       Window_CAPTUREM_REFRESHWINDOW(TMData, imessage);
  758.       GT_EndRefresh(WindowInfo_CAPTUREM.Window, TRUE);
  759.       break;
  760.  
  761.     case IDCMP_MENUPICK:
  762.       if(result = Window_CAPTUREM_MENUPICK(TMData, imessage)) done = result;
  763.       break;
  764.  
  765.     case IDCMP_GADGETDOWN:
  766.       if(result = Window_CAPTUREM_GADGETDOWN(TMData, imessage)) done = result;
  767.       break;
  768.  
  769.     case IDCMP_GADGETUP:
  770.       if(result = Window_CAPTUREM_GADGETUP(TMData, imessage)) done = result;
  771.       break;
  772.  
  773.     case IDCMP_CLOSEWINDOW:
  774.       if(result = Window_CAPTUREM_CLOSEWINDOW(TMData, imessage)) done = result;
  775.       break;
  776.  
  777.     }
  778.  
  779.   return(done);
  780.   }
  781.  
  782. static VOID TM_RemoveWindow(struct TMWindowInfo *TMWindowInfo)
  783.   {
  784.   struct IntuiMessage *imessage;
  785.   struct Node *succ;
  786.  
  787.   if(TMWindowInfo->Window)
  788.     {
  789.     if(TMWindowInfo->Menu)
  790.       {
  791.       ClearMenuStrip(TMWindowInfo->Window);
  792.       FreeMenus(TMWindowInfo->Menu);
  793.       TMWindowInfo->Menu = NULL;
  794.       }
  795.  
  796.     if(TMWindowInfo->GT_IMsg)
  797.       {
  798.       GT_ReplyIMsg(TMWindowInfo->GT_IMsg);
  799.       TMWindowInfo->GT_IMsg = NULL;
  800.       }
  801.  
  802.     if(TMWindowInfo->Window->UserPort)
  803.       {
  804.       Forbid();
  805.       imessage = (struct IntuiMessage *) TMWindowInfo->Window->UserPort->mp_MsgList.lh_Head;
  806.       while(succ = imessage->ExecMessage.mn_Node.ln_Succ)
  807.         {
  808.         if(imessage->IDCMPWindow == TMWindowInfo->Window)
  809.           {
  810.           Remove((struct Node *) imessage);
  811.           ReplyMsg((struct Message *) imessage);
  812.           }
  813.         imessage = (struct IntuiMessage *) succ;
  814.         }
  815.       TMWindowInfo->Window->UserPort = NULL;
  816.       ModifyIDCMP(TMWindowInfo->Window, 0L);
  817.       Permit();
  818.       }
  819.  
  820.     CloseWindow(TMWindowInfo->Window);
  821.     TMWindowInfo->Window = NULL;
  822.     TMWindowInfo->Flags = 0;
  823.     }
  824.  
  825.   if(TMWindowInfo->FirstGadget)
  826.     {
  827.     FreeGadgets(TMWindowInfo->FirstGadget);
  828.     TMWindowInfo->FirstGadget = NULL;
  829.     }
  830.   }
  831.  
  832.